/**
 * 1 resolve 和 reject 谁在前就执行谁，并且只执行唯一一个，并且只执行一次
 * 2 只要内部没有reject，可以一直then下去，then的返回值会进入下一个then里
 * 3 resolve 可以接受Promise参数,接收啥状态就进入啥状态 reject不行，如果参数是具有then方法的对象，会转为promise对象，并立即执行对象的then方法
 * 4 .then 或者.catch中return一个Error,不会报错，会被.then捕获
 * 5 .then 第二参数相当于.catch，不过同一个.then里面，第二参数无法捕获第一参数的错误
 * 6 .then 或 .catch 返回的值不能是 promise 本身，否则会造成死循环。
 * 7 Promise 对象的错误具有“冒泡”性质，会一直向后传递，直到被 onReject 函数处理或 catch 语句捕获为止。
 * 8 await 等待成功，如果失败，await 后面的代码不会执行
 * 9 状态一旦改变，后续再次执行，会直接返回结果
 */

// TODO 7 Promise 对象的错误具有“冒泡”性质
var p0 = new Promise((resolve, reject) => {
	reject('error1')
})
	.then(value => {
		console.log(1) // 不执行
		return Promise.resolve()
	})
	.then(value => {
		console.log(2) // 不执行
		return Promise.resolve()
	})
	.catch(error => {
		console.log(2) // 执行
		console.log('error', error)
	})

// TODO 状态一旦改变，后续再次执行,then 或者 catch，会直接返回结果
const a = function () {
	return new Promise((res, rej) => {
		setTimeout(() => {
			console.log('Fetch: ', 123)
			res('ok')
		}, 1000)
	})
}

const b = a()
b.then(res => {
	console.log(1, res)
})
b.then(res => {
	console.log(2, res)
})
// Fetch:  123
// 1 ok
// 2 ok

// async function foo() {
//     // throw '1'   // 进入reject
//     Error('2') // 进入resolve
// }

function p() {
	return new Promise((resolve, reject) => {
		console.log(1)

		Promise.resolve().then(res => {
			console.log(4)
		})

		Promise.reject().catch(err => {
			console.log(5)
			Promise.reject().catch(err => {
				console.log(7)
			})
		})

		// resolve(Promise.reject('主动 reject'))
		// reject(Promise.reject('主动 reject')) //报错

		resolve()

		console.log(2)

		reject(6)

		console.log(3)
	})
}
p()
	.then(res => {
		console.log(6, res)
	})
	.then(res => {
		console.log(8)
		return new Promise((resolve, reject) => {
			reject(9)
		})
	})
	.then(res => {
		console.log('res', res)
	})
	.catch(err => {
		console.log('err', err)
	})

